home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / seq_tests.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  8KB  |  336 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''
  5. Tests common to tuple, list and UserList.UserList
  6. '''
  7. import unittest
  8. from test import test_support
  9.  
  10. class CommonTest(unittest.TestCase):
  11.     type2test = None
  12.     
  13.     def test_constructors(self):
  14.         l0 = []
  15.         l1 = [
  16.             0]
  17.         l2 = [
  18.             0,
  19.             1]
  20.         u = self.type2test()
  21.         u0 = self.type2test(l0)
  22.         u1 = self.type2test(l1)
  23.         u2 = self.type2test(l2)
  24.         uu = self.type2test(u)
  25.         uu0 = self.type2test(u0)
  26.         uu1 = self.type2test(u1)
  27.         uu2 = self.type2test(u2)
  28.         v = self.type2test(tuple(u))
  29.         
  30.         class OtherSeq:
  31.             
  32.             def __init__(self, initseq):
  33.                 self._OtherSeq__data = initseq
  34.  
  35.             
  36.             def __len__(self):
  37.                 return len(self._OtherSeq__data)
  38.  
  39.             
  40.             def __getitem__(self, i):
  41.                 return self._OtherSeq__data[i]
  42.  
  43.  
  44.         s = OtherSeq(u0)
  45.         v0 = self.type2test(s)
  46.         self.assertEqual(len(v0), len(s))
  47.         s = 'this is also a sequence'
  48.         vv = self.type2test(s)
  49.         self.assertEqual(len(vv), len(s))
  50.  
  51.     
  52.     def test_truth(self):
  53.         self.assert_(not self.type2test())
  54.         self.assert_(self.type2test([
  55.             42]))
  56.  
  57.     
  58.     def test_getitem(self):
  59.         u = self.type2test([
  60.             0,
  61.             1,
  62.             2,
  63.             3,
  64.             4])
  65.         for i in xrange(len(u)):
  66.             self.assertEqual(u[i], i)
  67.             self.assertEqual(u[long(i)], i)
  68.         
  69.         for i in xrange(-len(u), -1):
  70.             self.assertEqual(u[i], len(u) + i)
  71.             self.assertEqual(u[long(i)], len(u) + i)
  72.         
  73.         self.assertRaises(IndexError, u.__getitem__, -len(u) - 1)
  74.         self.assertRaises(IndexError, u.__getitem__, len(u))
  75.         self.assertRaises(ValueError, u.__getitem__, slice(0, 10, 0))
  76.         u = self.type2test()
  77.         self.assertRaises(IndexError, u.__getitem__, 0)
  78.         self.assertRaises(IndexError, u.__getitem__, -1)
  79.         self.assertRaises(TypeError, u.__getitem__)
  80.         a = self.type2test([
  81.             10,
  82.             11])
  83.         self.assertEqual(a[0], 10)
  84.         self.assertEqual(a[1], 11)
  85.         self.assertEqual(a[-2], 10)
  86.         self.assertEqual(a[-1], 11)
  87.         self.assertRaises(IndexError, a.__getitem__, -3)
  88.         self.assertRaises(IndexError, a.__getitem__, 3)
  89.  
  90.     
  91.     def test_getslice(self):
  92.         l = [
  93.             0,
  94.             1,
  95.             2,
  96.             3,
  97.             4]
  98.         u = self.type2test(l)
  99.         self.assertEqual(u[0:0], self.type2test())
  100.         self.assertEqual(u[1:2], self.type2test([
  101.             1]))
  102.         self.assertEqual(u[-2:-1], self.type2test([
  103.             3]))
  104.         self.assertEqual(u[-1000:1000], u)
  105.         self.assertEqual(u[1000:-1000], self.type2test([]))
  106.         self.assertEqual(u[:], u)
  107.         self.assertEqual(u[1:None], self.type2test([
  108.             1,
  109.             2,
  110.             3,
  111.             4]))
  112.         self.assertEqual(u[None:3], self.type2test([
  113.             0,
  114.             1,
  115.             2]))
  116.         self.assertEqual(u[::], u)
  117.         self.assertEqual(u[::2], self.type2test([
  118.             0,
  119.             2,
  120.             4]))
  121.         self.assertEqual(u[1::2], self.type2test([
  122.             1,
  123.             3]))
  124.         self.assertEqual(u[::-1], self.type2test([
  125.             4,
  126.             3,
  127.             2,
  128.             1,
  129.             0]))
  130.         self.assertEqual(u[::-2], self.type2test([
  131.             4,
  132.             2,
  133.             0]))
  134.         self.assertEqual(u[3::-2], self.type2test([
  135.             3,
  136.             1]))
  137.         self.assertEqual(u[3:3:-2], self.type2test([]))
  138.         self.assertEqual(u[3:2:-2], self.type2test([
  139.             3]))
  140.         self.assertEqual(u[3:1:-2], self.type2test([
  141.             3]))
  142.         self.assertEqual(u[3:0:-2], self.type2test([
  143.             3,
  144.             1]))
  145.         self.assertEqual(u[::-100], self.type2test([
  146.             4]))
  147.         self.assertEqual(u[100:-100:], self.type2test([]))
  148.         self.assertEqual(u[-100:100:], u)
  149.         self.assertEqual(u[100:-100:-1], u[::-1])
  150.         self.assertEqual(u[-100:100:-1], self.type2test([]))
  151.         self.assertEqual(u[-0x64L:0x64L:0x2L], self.type2test([
  152.             0,
  153.             2,
  154.             4]))
  155.         a = self.type2test([
  156.             0,
  157.             1,
  158.             2,
  159.             3,
  160.             4])
  161.         self.assertEqual(a[-pow(2, 0x80L):3], self.type2test([
  162.             0,
  163.             1,
  164.             2]))
  165.         self.assertEqual(a[3:pow(2, 0x91L)], self.type2test([
  166.             3,
  167.             4]))
  168.         self.assertRaises(TypeError, u.__getslice__)
  169.  
  170.     
  171.     def test_contains(self):
  172.         u = self.type2test([
  173.             0,
  174.             1,
  175.             2])
  176.         for i in u:
  177.             self.assert_(i in u)
  178.         
  179.         for i in (min(u) - 1, max(u) + 1):
  180.             self.assert_(i not in u)
  181.         
  182.         self.assertRaises(TypeError, u.__contains__)
  183.  
  184.     
  185.     def test_len(self):
  186.         self.assertEqual(len(self.type2test()), 0)
  187.         self.assertEqual(len(self.type2test([])), 0)
  188.         self.assertEqual(len(self.type2test([
  189.             0])), 1)
  190.         self.assertEqual(len(self.type2test([
  191.             0,
  192.             1,
  193.             2])), 3)
  194.  
  195.     
  196.     def test_minmax(self):
  197.         u = self.type2test([
  198.             0,
  199.             1,
  200.             2])
  201.         self.assertEqual(min(u), 0)
  202.         self.assertEqual(max(u), 2)
  203.  
  204.     
  205.     def test_addmul(self):
  206.         u1 = self.type2test([
  207.             0])
  208.         u2 = self.type2test([
  209.             0,
  210.             1])
  211.         self.assertEqual(u1, u1 + self.type2test())
  212.         self.assertEqual(u1, self.type2test() + u1)
  213.         self.assertEqual(u1 + self.type2test([
  214.             1]), u2)
  215.         self.assertEqual(self.type2test([
  216.             -1]) + u1, self.type2test([
  217.             -1,
  218.             0]))
  219.         self.assertEqual(self.type2test(), u2 * 0)
  220.         self.assertEqual(self.type2test(), 0 * u2)
  221.         self.assertEqual(self.type2test(), u2 * 0x0L)
  222.         self.assertEqual(self.type2test(), 0x0L * u2)
  223.         self.assertEqual(u2, u2 * 1)
  224.         self.assertEqual(u2, 1 * u2)
  225.         self.assertEqual(u2, u2 * 0x1L)
  226.         self.assertEqual(u2, 0x1L * u2)
  227.         self.assertEqual(u2 + u2, u2 * 2)
  228.         self.assertEqual(u2 + u2, 2 * u2)
  229.         self.assertEqual(u2 + u2, u2 * 0x2L)
  230.         self.assertEqual(u2 + u2, 0x2L * u2)
  231.         self.assertEqual(u2 + u2 + u2, u2 * 3)
  232.         self.assertEqual(u2 + u2 + u2, 3 * u2)
  233.         
  234.         class subclass(self.type2test):
  235.             pass
  236.  
  237.         u3 = subclass([
  238.             0,
  239.             1])
  240.         self.assertEqual(u3, u3 * 1)
  241.         self.assert_(u3 is not u3 * 1)
  242.  
  243.     
  244.     def test_iadd(self):
  245.         u = self.type2test([
  246.             0,
  247.             1])
  248.         u += self.type2test()
  249.         self.assertEqual(u, self.type2test([
  250.             0,
  251.             1]))
  252.         u += self.type2test([
  253.             2,
  254.             3])
  255.         self.assertEqual(u, self.type2test([
  256.             0,
  257.             1,
  258.             2,
  259.             3]))
  260.         u += self.type2test([
  261.             4,
  262.             5])
  263.         self.assertEqual(u, self.type2test([
  264.             0,
  265.             1,
  266.             2,
  267.             3,
  268.             4,
  269.             5]))
  270.         u = self.type2test('spam')
  271.         u += self.type2test('eggs')
  272.         self.assertEqual(u, self.type2test('spameggs'))
  273.  
  274.     
  275.     def test_imul(self):
  276.         u = self.type2test([
  277.             0,
  278.             1])
  279.         u *= 3
  280.         self.assertEqual(u, self.type2test([
  281.             0,
  282.             1,
  283.             0,
  284.             1,
  285.             0,
  286.             1]))
  287.  
  288.     
  289.     def test_getitemoverwriteiter(self):
  290.         
  291.         class T(self.type2test):
  292.             
  293.             def __getitem__(self, key):
  294.                 return str(key) + '!!!'
  295.  
  296.  
  297.         self.assertEqual(iter(T((1, 2))).next(), 1)
  298.  
  299.     
  300.     def test_repeat(self):
  301.         for m in xrange(4):
  302.             s = tuple(range(m))
  303.             for n in xrange(-3, 5):
  304.                 self.assertEqual(self.type2test(s * n), self.type2test(s) * n)
  305.             
  306.             self.assertEqual(self.type2test(s) * -4, self.type2test([]))
  307.             self.assertEqual(id(s), id(s * 1))
  308.         
  309.  
  310.     
  311.     def test_subscript(self):
  312.         a = self.type2test([
  313.             10,
  314.             11])
  315.         self.assertEqual(a.__getitem__(0x0L), 10)
  316.         self.assertEqual(a.__getitem__(0x1L), 11)
  317.         self.assertEqual(a.__getitem__(-0x2L), 10)
  318.         self.assertEqual(a.__getitem__(-0x1L), 11)
  319.         self.assertRaises(IndexError, a.__getitem__, -3)
  320.         self.assertRaises(IndexError, a.__getitem__, 3)
  321.         self.assertEqual(a.__getitem__(slice(0, 1)), self.type2test([
  322.             10]))
  323.         self.assertEqual(a.__getitem__(slice(1, 2)), self.type2test([
  324.             11]))
  325.         self.assertEqual(a.__getitem__(slice(0, 2)), self.type2test([
  326.             10,
  327.             11]))
  328.         self.assertEqual(a.__getitem__(slice(0, 3)), self.type2test([
  329.             10,
  330.             11]))
  331.         self.assertEqual(a.__getitem__(slice(3, 5)), self.type2test([]))
  332.         self.assertRaises(ValueError, a.__getitem__, slice(0, 10, 0))
  333.         self.assertRaises(TypeError, a.__getitem__, 'x')
  334.  
  335.  
  336.